/**
* 法术技能演算 法术计算
* @param {*} fight_data 
* @param {*} skill_name 
* @param {*} src_unit 
* @param {*} target_unit 
* @returns 
*/
export function computing_ap_skill(fight_data, src_unit, target_unit, skill_name, skill_level, damage_ratio) {
    console.debug(`法术技能演算 ===> 编号 ${src_unit["编号"]} ${src_unit["气血"]} 目标编号 ${target_unit["编号"]} `)
    if (skill_level === undefined) {
        skill_level = G.FightUnitUtils.get_unit_skill_level(src_unit, skill_name);
    }
    if (damage_ratio === undefined) {
        damage_ratio = 1;
    }
    //演算伤害流程
    computing_ap_skill_damage(fight_data, src_unit, target_unit, skill_name, skill_level, damage_ratio);

    // 法术连击计算
    let skill_data = G.SkillData.default[skill_name];
    if (skill_data && skill_data["法术连击"]) {
        console.debug(`法术连击计算 => kill_name ${skill_name}`);
        skill_data["法术连击"](fight_data, src_unit, target_unit, skill_level);
    }

    // 如意神通类技能概率连击
    if (skill_data["如意神通"] && src_unit["法术状态"]["齐天神通"] && G.RandomUtils.chance(50)) {
        console.debug(`齐天神通 额外施法 ===> 编号 ${src_unit["编号"]}`)
        computing_ap_skill_damage(fight_data, src_unit, target_unit, skill_name, skill_level, 1);
        return;
    }

    //佛法加成的技能概率连击
    if (src_unit["法术状态"]["佛法无边"]) {
        if (G.SkillData.default[skill_name]["佛法加成"] && G.RandomUtils.chance(src_unit["法术状态"]["佛法无边"]["法连几率"])) {
            computing_ap_skill_damage(fight_data, src_unit, target_unit, skill_name, skill_level, 1);
        }
    }
}


/**
 * 计算法术技能的流程和伤害 法攻技能计算(编号,名称,等级,伤害系数,消耗,战斗数据)
 * @param {*} fight_data 
 * @param {*} src_unit 
 * @param {*} target_unit 
 * @param {*} skill_name 
 * @param {*} skill_level 
 * @param {*} damage_ratio 伤害系数 
 * @returns 
 */
export function computing_ap_skill_damage(fight_data, src_unit, target_unit, skill_name, skill_level, damage_ratio) {
    console.debug(`计算法术技能的流程和伤害 => src_unit ${src_unit["编号"]} target_unit ${target_unit["编号"]}`)
    let skill_data = G.SkillData.default[skill_name];
    let target_count = 1;

    // 目标数量计算 从技能配置取
    if (skill_data["目标"]) {
        target_count = skill_data["目标"](fight_data, src_unit, target_unit, skill_level);
    } else {
        console.debug(`法术技能 ${skill_name} 未定义目标计算`);
    }

    // 如果目标已经不可操作则更换目标
    if (target_unit === undefined) {
        target_unit = G.FightUtils.get_enemy_team_single_survive_unit(fight_data, src_unit);
        console.debug(`计算法术技能的流程和伤害 ===> 目标单位不存在 重新寻找目标单位：${target_unit !== undefined}`);
    } else if (!G.FightUnitUtils.get_target_unit_status(src_unit, target_unit, 1)) {
        target_unit = G.FightUtils.get_enemy_team_single_survive_unit(fight_data, src_unit);
        console.debug(`计算法术技能的流程和伤害 ===> 目标单位无法选中 重新寻找目标单位：${target_unit !== undefined}`);
    }
    if (target_unit === undefined) {
        console.debug(`计算法术技能的流程和伤害 ===> 仍然找不到目标单位，跳过`);
        return false;
    }

    // 技能如果技能攻击目标是多个 则获取到的是多个敌人
    let target_unit_list = G.FightUtils.get_enemy_team_group_survive_unit(fight_data, src_unit, target_unit, target_count);

    target_count = target_unit_list.length;

    if (target_count === 0) {
        console.debug(`计算法术技能 ===> 没有目标单位，跳过`);
        return false;
    }

    // 获取技能消耗数据
    let consummer_value = 0;
    let consummer_type = "";
    if (skill_data && skill_data["消耗"]) {
        let res = skill_data["消耗"](fight_data, src_unit, target_count);
        if (res) {
            consummer_value = res[0];
            consummer_type = res[1];
        }
    }

    // 如果需要的消耗类型不够则行动失败
    if (!G.FightUnitUtils.excute_unit_skill_consummer(fight_data, src_unit, consummer_type, consummer_value, skill_name)) {
        fight_data["战斗流程"].push({ "流程": 6, "战斗提示": { "内容": "行动失败", "编号": src_unit["编号"] } });
        return;
    }

    // 初始化法术流程信息
    fight_data["战斗流程"].push({ "流程": 200, "攻击方": src_unit["编号"], "被攻击": [], "提示": { "允许": true, "类型": "法术", "名称": `${src_unit["名称"]}使用了${skill_name}` }, "技能提示": { "内容": `【法术】${skill_name}`, "编号": src_unit["编号"] } });
    G.FightUtils.add_waiting_play_time(fight_data, 2, "法术技能");
    if (src_unit["类型"] === "角色") {
        if (!fight_data["PK战斗"]) {
            src_unit["统计数据"]["施法"] += 1;
        }
    }

    // 攻击单位法术状态对法术伤害系数的影响
    for (const key in src_unit["法术状态"]) {
        if (G.SkillData.default[key] && G.SkillData.default[key]["法术伤害系数"]) {
            G.SkillData.default[key]["法术伤害系数"](fight_data, src_unit, target_unit, target_unit_list, damage_ratio);
        }
    }

    // 攻击单位奇经八脉对法术伤害系数的影响
    if (src_unit["奇经八脉"] && src_unit["门派"] !== "无门派") {
        let sects_jing_mai_data = G.JingMaiData.default[src_unit["门派"]];
        // 已点经脉
        for (const key in src_unit["奇经八脉"]) {
            if (src_unit["奇经八脉"][key] === 1 && sects_jing_mai_data[key] && sects_jing_mai_data[key]["法术伤害系数"]) {
                sects_jing_mai_data[key]["法术伤害系数"](fight_data, src_unit, target_unit, target_unit_list, damage_ratio);
            }
        }
    }

    // 技能的伤害系数算法
    if (skill_data && skill_data["法术伤害系数"]) {
        skill_data["法术伤害系数"](fight_data, src_unit, target_unit, target_unit_list, damage_ratio);
        console.debug(`计算技能法术伤害系数 => kill_name ${skill_name} damage_ratio ${damage_ratio}`);
    }

    // 出其不意
    if (src_unit["认证码"] && src_unit["特殊状态"]["出其不意"] &&
        !fight_data["特殊状态"]["出其不意"][src_unit["队伍"]]["技能"].has(skill_name)) {
        damage_ratio = damage_ratio * 1.15;
    }

    for (let index = 0; index < target_unit_list.length; index++) {
        //法攻技能流程计算
        console.debug(`计算法术技能的流程和伤害 => 开始第${index}个目标法攻技能流程计算, 目标气血：${target_unit_list[index]["气血"]}`);
        computing_ap_skill_process_data(fight_data, src_unit, target_unit_list, index, skill_name, skill_level, damage_ratio);
    }

    //法术攻击后指定技能算法
    src_unit["被反弹"] = undefined
    if (skill_data && skill_data["法攻后触发"]) {
        console.debug(`法攻后触发 => kill_name ${skill_name}`);
        skill_data["法攻后触发"](fight_data, src_unit, skill_level);
    }

    // 法术攻击后 指定法术状态算法
    for (const key in src_unit["法术状态"]) {
        console.debug(`法攻后触发 => 法术状态 ${key}`);
        if (G.SkillData.default[key] && G.SkillData.default[key]["法攻后触发"]) {
            G.SkillData.default[key]["法攻后触发"](fight_data, src_unit, skill_level);
        }
    }

    // 法术攻击后 特殊状态算法
    for (const key in src_unit["特殊状态"]) {
        console.debug(`法攻后触发 => 特殊状态 ${key}`);
        if (G.SkillData.default[key] && G.SkillData.default[key]["法攻后触发"]) {
            G.SkillData.default[key]["法攻后触发"](fight_data, src_unit, target_unit_list, skill_name, skill_level);
        }
    }
}

/**
 * 法攻技能流程计算
 * @param {*} fight_data 
 * @param {*} src_unit 
 * @param {*} target_list 
 * @param {*} target_index 
 * @param {*} skill_name 
 * @param {*} damage_ratio 
 * @returns 
 */
function computing_ap_skill_process_data(fight_data, src_unit, target_list, target_index, skill_name, skill_level, damage_ratio) {
    console.debug(`法攻技能流程计算 => src_unit ${src_unit["编号"]} size ${target_list.length} target_index ${target_index} skill_name ${skill_name} damage_ratio ${damage_ratio}`)
    // 本次目标
    let target_unit = target_list[target_index];
    console.debug(`法攻技能流程计算 => 目标气血 ${target_unit["气血"]}`)
    let current_process_data_index = fight_data["战斗流程"].length - 1;
    let process_data = fight_data["战斗流程"][current_process_data_index];
    // 初始化本次流程被攻击方的数据
    process_data["被攻击"][target_index] = { "特效": [], "编号": target_unit["编号"] };
    let tx = process_data["被攻击"][target_index]["特效"];
    // 目标直接免疫本次攻击的处理
    if (target_unit["法术状态"]["天地同寿"]) {
        console.debug(`法攻技能流程计算 => 天地同寿 结束`)
        process_data["被攻击"][target_index]["免疫"] = true;
        return;
    }
    if (target_unit["法术状态"] && target_unit["法术状态"]["分身术"] && target_unit["法术状态"]["分身术"]["破解"] === undefined) {
        console.debug(`法攻技能流程计算 => 分身术 破解 结束`)
        target_unit["法术状态"]["分身术"]["破解"] = 1;
        process_data["被攻击"][target_index]["免疫"] = true;
        return;
    }
    // 目标直接躲避攻击的处理
    if (src_unit["门派"] !== "龙宫" && !G.FightUnitUtils.check_fight_unit_passive_skill(src_unit, "度厄") && !ex_skill[skill_name]) {
        if (target_unit["门派"] === "天宫") {
            let gl = 15
            if (target_unit["法术状态"]["颠倒五行"]) {
                gl = gl + 7
                if (target_unit["法术状态"] && target_unit["法术状态"]["颠倒五行"] && target_unit["法术状态"]["颠倒五行"]["增加躲避"]) {
                    gl = gl + 15
                    if (gl >= 25) {
                        gl = 25
                    }
                }
            }
            if (target_unit["软烟罗锦"]) {
                gl = gl + target_unit["软烟罗锦"];
            }
            if (G.RandomUtils.chance(gl)) {
                process_data["被攻击"][target_index]["躲避"] = true;
                return;
            }
        } else {
            let gl = 1
            if (target_unit["法术状态"] && target_unit["法术状态"]["颠倒五行"]) {
                gl = 8
                if (target_unit["法术状态"]["颠倒五行"]["增加躲避"]) {
                    gl = 16
                }
            }
            if (target_unit["软烟罗锦"]) {
                gl = gl + target_unit["软烟罗锦"]
            }
            if (G.RandomUtils.chance(gl)) {
                process_data["被攻击"][target_index]["躲避"] = true;
                return;
            }
        }
    }

    let skill_data = G.SkillData.default[skill_name];
    // 特定技能会根据条件使用具体随机名称
    if (skill_data["随机法术"]) {
        skill_name = skill_data["随机法术"](src_unit, target_list);
    }

    // 添加技能到流程特效
    tx.push(skill_name);

    // 伤害
    let damage = 1;
    // 法暴倍率
    let fbbl = 2;
    // 吸收
    let xs = undefined;
    // 弱点
    let rd = undefined;

    // 技能伤害和法爆倍率计算
    if (skill_data["法术伤害"]) {
        console.debug(`法术伤害计算开始 ==> 技能 ${skill_name}  伤害 ${damage}  法暴倍率 ${fbbl}`)
        let res = skill_data["法术伤害"](fight_data, src_unit, target_unit, target_list, target_index, skill_level);
        damage = res[0];
        if (res[1]) {
            fbbl = res[1];
        }
        console.debug(`法术伤害计算结束 ==> 技能 ${skill_name}  伤害 ${damage}  法暴倍率 ${fbbl}`)
    } else {
        // 如果未定义技能的计算方法则直接取灵力伤害
        console.warn(`技能 ${skill_name} 未定义伤害算法直接取灵力伤害`)
        damage = G.FightSkillUtils.get_ll_damage(fight_data, src_unit, target_unit);
    }

    // 超级抵抗减少伤害
    if (target_unit["超法抵抗"]) {
        damage = Math.floor(damage * 0.5);
    }
    // 获取法术的吸收和弱点配置
    if (G.Skill.ap_skill_xs_rd_conf[skill_name]) {
        let conf = G.Skill.ap_skill_xs_rd_conf[skill_name];
        xs = conf["吸收"];
        rd = conf["弱点"];
    }

    damage = Math.floor(damage * damage_ratio);
    console.debug(`法术乘以伤害系数结果 => ${damage}`);

    // 获取法术伤害结果
    let damage_result = get_ap_skill_dagama_reault(fight_data, src_unit, target_unit, skill_name, damage, fbbl, xs, rd);

    // 法术共生计算
    if (target_index === 0 && target_unit["共生"]) {
        console.debug(`法攻技能流程计算 => 法术共生计算`)
        // TODO 战斗技能:法术共生计算(战斗数据,编号,目标,Math.floor(伤害.伤害+1),伤害.特效,执行数,目标数)
        return;
    }

    //根据伤害类型做反击、反震、溅射计算
    if (damage_result["类型"] === 1) {
        if (process_data["反震伤害"] === undefined && damage_result["伤害"] >= 4 && target_unit["法术反震"] && src_unit["特殊状态"]["法术波动上限"] === undefined && G.RandomUtils.chance(30)) {
            let fz_damage = Math.floor(damage_result["伤害"] * target_unit["法术反震"]);
            process_data["反震伤害"] = fz_damage;
            console.debug(`计算法术技能的流程和伤害 => 反震伤害 单位掉血计算 目标气血 ${src_unit["气血"]}`)
            let die = G.FightComputingUtils.computing_remove_hp(fight_data, target_unit, src_unit, fz_damage);
            process_data["反震死亡"] = die;
            tx.push("反震");
            G.FightUtils.add_waiting_play_time(fight_data, 1, "法术反震");
            console.debug(`法攻技能流程计算 => 法术反震`)
        }

        // 被攻击单位法术状态伤害反弹
        for (const key in target_unit["法术状态"]) {
            if (G.SkillData.default[key] && G.SkillData.default[key]["被攻击法伤反弹"]) {
                console.debug(`被攻击法伤反弹 ===>  法术状态 ${key}`);
                let res = G.SkillData.default[key]["被攻击法伤反弹"](fight_data, src_unit, target_unit, damage_result["伤害"]);
                if (res) {
                    return;
                }
            }
        }

        // 修罗咒被攻击反震计算
        if (target_unit["法术状态"]["修罗咒"]) {
            G.SkillData.default["修罗咒"]["反震计算"](fight_data, src_unit, target_unit, damage);
        }

        // 溅射计算
        if (skill_data["溅射计算"]) {
            skill_data["溅射计算"](fight_data, src_unit, target_unit, damage);
        }
    }

    process_data["被攻击"][target_index]["伤害"] = damage_result["伤害"];
    process_data["被攻击"][target_index]["类型"] = damage_result["类型"];
    for (let index = 0; index < damage_result["特效"].length; index++) {
        if (!tx.includes(damage_result["特效"][index])) {
            tx.push(damage_result["特效"][index]);
        }

    }
    // 根据伤害结果决定是增加气血还是扣除气血
    if (damage_result["类型"] === 2) {
        //回血
        console.debug(`计算法术技能的流程和伤害 => 最后一步 增加气血 目标气血 ${target_unit["气血"]}`)
        G.FightComputingUtils.add_target_hp_and_play(fight_data, target_unit, damage_result["伤害"]);
    } else {
        console.debug(`计算法术技能的流程和伤害 => 最后一步 单位掉血计算 目标气血 ${target_unit["气血"]}`)
        let die = G.FightComputingUtils.computing_remove_hp(fight_data, src_unit, target_unit, damage_result["伤害"]);
        process_data["被攻击"][target_index]["死亡"] = die;
        //火甲术反击
        if (target_unit["法术状态"]["火甲术"]) {
            computing_ap_skill(fight_data, target_unit, src_unit, "三昧真火", target_unit["等级"], 0.5);
        }
    }
}

/**
 * 获取法术伤害结果
 * @param {*} fight_data 
 * @param {*} src_unit 
 * @param {*} target_unit 
 * @param {*} skill_name 
 * @param {*} damage 
 * @param {*} fbbl 
 * @param {*} xs 
 * @param {*} rd 
 * @returns 
 */
export function get_ap_skill_dagama_reault(fight_data, src_unit, target_unit, skill_name, damage, fbbl, xs, rd) {
    console.debug(`获取法术伤害结果 : src_unit ${src_unit["编号"]} target_unit ${target_unit["编号"]} skill_name ${skill_name} damage ${damage}`)
    let fbjl = 0;

    // 攻击单位法术状态对法术伤害结果的影响
    for (const key in src_unit["法术状态"]) {
        if (G.SkillData.default[key] && G.SkillData.default[key]["法术伤害结果"]) {
            console.debug(`基础物理伤害 ===>  法术状态 ${key}`);
            G.SkillData.default[key]["法术伤害结果"](fight_data, src_unit, target_unit, damage, fbjl, fbbl);
        }
    }

    // 攻击单位特殊状态对法术伤害结果的影响
    for (const key in src_unit["特殊状态"]) {
        if (G.SkillData.default[key] && G.SkillData.default[key]["法术伤害结果"]) {
            console.debug(`法术伤害结果 ===>  攻击特殊状态 ${key}`);
            G.SkillData.default[key]["法术伤害结果"](fight_data, src_unit, target_unit, damage, fbjl, fbbl);
        }
    }

    // 被攻击单位特殊状态对法术伤害结果的影响
    for (const key in target_unit["特殊状态"]) {
        if (G.SkillData.default[key] && G.SkillData.default[key]["法术伤害结果"]) {
            console.debug(`法术伤害结果 ===>  被攻击特殊状态 ${key}`);
            G.SkillData.default[key]["法术伤害结果"](fight_data, src_unit, target_unit, damage, fbjl, fbbl);
        }
    }

    if (src_unit["法术暴击等级"] && target_unit["抗法术暴击等级"] && target_unit["等级"]) {
        fbjl = (src_unit["法术暴击等级"] - target_unit["抗法术暴击等级"]) * 10 / target_unit["等级"];
    }
    if (src_unit["法术状态"]["超级进阶法爆"]) {
        fbjl += 20;
    } else if (src_unit["法术状态"]["高级进阶法爆"]) {
        fbjl += 20;
    } else if (src_unit["法术状态"]["进阶法爆"]) {
        fbjl += 10;
    } else if (src_unit["法术状态"]["灵彻太虚"]) {
        fbjl -= 5;
    }
    if (src_unit["斩浪"]) {
        fbjl += src_unit["斩浪"];
        src_unit["斩浪"] = undefined;
    } else if (fight_data["PK战斗"] && G.FightUnitUtils.check_fight_unit_jingmai(src_unit, "呼风") && target_unit["魔法"] < target_unit["最大魔法"] * 0.3) {
        fbjl += 5
    }
    if (G.FightUnitUtils.check_fight_unit_jingmai(src_unit, "魔王寨", "焚尽")) {

        if (G.FightUnitUtils.get_unit_equipment_wx(src_unit, 2) === "火") { //武器
            fbjl += 4
        }
        if (G.FightUnitUtils.get_unit_equipment_wx(src_unit, 3) === "火") { //衣服
            fbjl += 4
        }
    }
    if (src_unit["法身"] && src_unit["法术状态"]["风灵"]) {
        fbjl += src_unit["法术状态"]["风灵"]["层数"] * 2
    }

    // 技能法爆算法
    let skill_data = G.SkillData.default[skill_name];
    if (skill_data && skill_data["法爆几率"]) {
        skill_data["法爆几率"](fight_data, src_unit, target_unit, fbjl);
    }

    let fb_ok = false
    if (G.RandomUtils.chance(src_unit["法暴"] + fbjl)) {
        fb_ok = true;
        if (src_unit["进阶法爆"] === 21) {
            fbbl = fbbl + 0.5
        }

        // TODO
        if (G.FightUnitUtils.check_fight_unit_jingmai(target_unit, "无底洞", "灵身")) {
            fbbl = fbbl - 0.4
        }

        if (G.FightUnitUtils.check_fight_unit_jingmai(target_unit, "凌波城", "神躯")) {
            fbbl = fbbl - 0.2
        }

        if (target_unit["统御属性"] && target_unit["统御属性"]["铜墙铁壁"]) {
            fbbl = fbbl - target_unit["统御属性"]["铜墙铁壁"]
        }
        if (target_unit["神器"] && target_unit["神器"]["佩戴"] && target_unit["神器"]["名称"] === "定风波") {
            fbbl = fbbl - 0.3 * target_unit["神器"]["等级"];
        }
        if (fbbl < 1) {
            fbbl = 1
        }
        damage = Math.floor(damage * fbbl);
        if (src_unit["法术暴击伤害"]) {
            damage += Math.floor(damage * src_unit["法术暴击伤害"]);
        }
    }

    let damage_type = 1;
    //技能是否能被吸收
    if (xs) {
        let is_xs = false;
        let cjgv = 0;
        if (xs === "土" && target_unit["土吸"]) {
            is_xs = true;
            if (target_unit["超土吸"]) { cjgv = 100 }
        } else if (xs === "水" && target_unit["水吸"]) {
            is_xs = true;
            if (target_unit["超水吸"]) { cjgv = 100 }
        } else if (xs === "火" && target_unit["火吸"]) {
            is_xs = true;
            if (target_unit["超火吸"]) { cjgv = 100 }
        } else if (xs === "雷" && target_unit["雷吸"]) {
            is_xs = true;
            if (target_unit["超雷吸"]) { cjgv = 100 }
        }
        if (is_xs) {
            if (G.RandomUtils.chance(30 + cjgv)) {
                damage = Math.floor(damage * 0.3)
                damage_type = 2;
            } else { //吸收失败也可减少法术伤害的30%
                damage = Math.floor(damage * 0.7)
            }
        } else if (target_unit["法术状态"]["颠倒五行"]) {
            if (G.RandomUtils.chance(30)) {
                damage = Math.floor(damage * 0.3)
                damage_type = 2;
            }
        } else if (G.FightUnitUtils.check_unit_fa_bao(fight_data, target_unit, "谷玄星盘")) {
            let gl = Math.floor(G.FightUnitUtils.get_unit_fa_bao_jingjie(target_unit, "谷玄星盘") * 0.7);
            if (G.RandomUtils.chance(gl)) {
                damage = Math.floor(damage * 0.3)
                damage_type = 2;
            }
        }
    } else if (target_unit["法术状态"] && target_unit["法术状态"]["分水"] && G.RandomUtils.chance(60)) {
        damage = G.RandomUtils.generate_random(40, target_unit["法术状态"]["分水"]["境界"] * 15);
        damage_type = 2;
    }

    if (damage_type === 1) {
        if (rd) { //好像弱点和吸收是冲突的
            if (rd === "土" && target_unit["弱点土"] && target_unit["法术状态"]["弱点土"] === undefined) {
                damage = Math.floor(damage * 1.5)
            } else if (rd === "雷" && target_unit["弱点雷"] && target_unit["法术状态"]["弱点土"] === undefined) {
                damage = Math.floor(damage * 1.5)
            } else if (rd === "火" && target_unit["弱点火"] && target_unit["法术状态"]["弱点火"] === undefined) {
                damage = Math.floor(damage * 1.5)
            } else if (rd === "水" && target_unit["弱点水"] && target_unit["法术状态"]["弱点水"] === undefined) {
                damage = Math.floor(damage * 1.5)
            } else if (rd === "雷" && target_unit["法术状态"]["弱点雷"]) {
                damage = Math.floor(damage * 1.5)
            } else if (rd === "火" && target_unit["法术状态"]["弱点火"]) {
                damage = Math.floor(damage * 1.5)
            } else if (rd === "土" && target_unit["法术状态"]["弱点土"]) {
                damage = Math.floor(damage * 1.5)
            } else if (rd === "水" && target_unit["法术状态"]["弱点水"]) {
                damage = Math.floor(damage * 1.5);
            }
        }
        if (src_unit["特殊状态"]["法术波动上限"]) {
            damage = Math.floor(damage * G.RandomUtils.generate_random(src_unit["特殊状态"]["法术波动下限"], src_unit["特殊状态"]["法术波动上限"]) / 100);
        }
    }
    if (damage < 1) {
        damage = 1;
    }
    damage = Math.floor(damage);
    if (damage_type === 1) {
        return G.FightComputingUtils.get_damage_result(fight_data, src_unit, target_unit, damage, fb_ok, skill_name, false, false, 2);
    } else {
        damage_type = 2;
        let data = { "伤害": Math.floor(damage), "类型": damage_type, "特效": [] };
        console.debug(`获取法术伤害结果 => : ${JSON.stringify(data)}`)
        return data;
    }
}